package q1.project.core.jpa;

import jakarta.persistence.criteria.*;
import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import org.springframework.data.domain.*;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.util.StringUtils;
import q1.project.core.base.PageQuery;
import q1.project.core.exception.BusinessException;

/**
 * JPA动态查询条件构建器
 *
 * <p>这是一个功能强大的JPA查询条件构建工具，支持链式调用构建复杂的动态查询条件。 可以将查询条件从model对象中自动提取，也可以手动指定值。
 *
 * <p>
 *
 * <h3>使用示例：</h3>
 *
 * <pre>{@code
 * // 示例1：基本使用 - 从model对象中提取条件
 * public Page<UserEntity> searchUsers(UserQuery query) {
 *     WhereBuilderNow<UserEntity> builder = new WhereBuilderNow<>();
 *     builder.init(query); // 初始化，从query对象中提取条件
 *
 *     Specification<UserEntity> spec = builder.build(w -> {
 *         w.stringContain("username");  // 从query对象中提取username字段进行模糊查询
 *         w.stringEqual("email");       // 精确匹配email
 *         w.intEqual("status");         // 精确匹配status
 *         w.dateTimeBetween("createTime", query.getStartTime(), query.getEndTime(), null);
 *         w.ascOrder("createTime");     // 按创建时间升序
 *     });
 *
 *     Pageable pageable = builder.getPageable(); // 从query对象中提取分页参数
 *     return userDao.findAll(spec, pageable);
 * }
 *
 * // 示例2：手动指定值
 * public List<UserEntity> findActiveUsers() {
 *     WhereBuilderNow<UserEntity> builder = new WhereBuilderNow<>();
 *
 *     Specification<UserEntity> spec = builder.build(w -> {
 *         w.booleanEqual("active", true);           // 激活状态为true
 *         w.stringNotEqual("username", "admin");    // 用户名不等于admin
 *         w.intThan("age", 18);                      // 年龄大于18
 *         w.dateTimeThan("createTime", "2024-01-01 00:00:00", "yyyy-MM-dd HH:mm:ss");
 *         w.descOrder("createTime");                 // 按创建时间降序
 *     });
 *
 *     return userDao.findAll(spec);
 * }
 *
 * // 示例3：复杂条件组合
 * public Page<ProductEntity> searchProducts(ProductQuery query) {
 *     WhereBuilderNow<ProductEntity> builder = new WhereBuilderNow<>();
 *     builder.init(query);
 *
 *     Specification<ProductEntity> spec = builder.build(w -> {
 *         // 字符串条件
 *         w.stringContain("name");              // 名称包含
 *         w.stringIn("category", query.getCategories()); // 分类在列表中
 *         w.stringIsNotBlank("description");   // 描述不为空
 *
 *         // 数值条件
 *         w.longBetween("price", query.getMinPrice(), query.getMaxPrice()); // 价格区间
 *         w.intEqual("status");                 // 状态等于
 *
 *         // 日期条件
 *         w.dateTimeBetween("createTime", query.getStartDate(), query.getEndDate(), null);
 *
 *         // 特殊条件
 *         w.isNotNull("imageUrl");              // 图片URL不为空
 *         w.keywordSearch(query.getKeyword(), "name", "description"); // 关键词搜索多个字段
 *
 *         // 排序
 *         w.ascOrder("price");
 *         w.descOrder("createTime");
 *     });
 *
 *     Pageable pageable = builder.getPageable();
 *     return productDao.findAll(spec, pageable);
 * }
 *
 * // 示例4：使用PageQuery分页
 * public Page<UserEntity> searchWithPageQuery(PageQuery pageQuery, UserQuery query) {
 *     WhereBuilderNow<UserEntity> builder = new WhereBuilderNow<>();
 *     builder.init(query);
 *
 *     Specification<UserEntity> spec = builder.build(w -> {
 *         w.stringContain("username");
 *         w.intEqual("status");
 *     });
 *
 *     Pageable pageable = builder.getPageable(pageQuery.getPage(), pageQuery.getSize());
 *     return userDao.findAll(spec, pageable);
 * }
 * }</pre>
 *
 * <h3>支持的条件类型：</h3>
 *
 * <ul>
 *   <li><b>字符串条件：</b>stringEqual, stringNotEqual, stringContain, stringIn, stringNotIn,
 *       stringIsBlank, stringIsNotBlank, stringIsNotBlankOrNotNull, stringIsBlankOrNull
 *   <li><b>整数条件：</b>intEqual, intNotEqual, intThan, intLess, intIn, intBetween
 *   <li><b>长整型条件：</b>longEqual, longThan, longLess, longBetween
 *   <li><b>布尔条件：</b>booleanEqual
 *   <li><b>日期时间条件：</b>dateTimeThan, dateTimeLess, dateTimeBetween, dateEqual, dateThan, dateLess,
 *       dateBetween, timeThan, timeLess, timeBetween
 *   <li><b>BigDecimal条件：</b>bigDecimalGreaterThan, bigDecimalLessThan
 *   <li><b>特殊条件：</b>isNull, isNotNull, keywordSearch
 *   <li><b>排序：</b>ascOrder, descOrder, ascOrderString
 * </ul>
 *
 * <h3>注意事项：</h3>
 *
 * <ul>
 *   <li>如果使用init()方法初始化model对象，则可以从model对象中自动提取字段值
 *   <li>如果不使用init()，则需要手动指定每个条件的值
 *   <li>分页参数可以从model对象中提取（page和size字段），也可以手动指定
 *   <li>所有条件方法都支持链式调用
 *   <li>如果值为null或空，条件会被自动忽略（不会添加到查询条件中）
 * </ul>
 *
 * @author sun
 * @date 2023/11/7
 * @modified 适配Spring Boot 3.x和当前项目结构
 */
public class WhereBuilderNow<T> {
  private Object model;
  private Predicate predicate;
  private CriteriaBuilder criteriaBuilder;
  private Root<T> root;
  private final List<Order> criteriaOrders = new ArrayList<>();
  private int defaultPage = 0; // 缺省页码
  private int defaultSize = 20; // 缺省每页大小

  /**
   * 初始化model对象
   *
   * <p>可以传递一个参数model对象过来，where条件的时候可以只传递表字段名， 缺省值可以从这个model对象里获取对应的属性值，属性名称和表字段名称一致。
   *
   * <p>这个函数也可以不调用，每次拼接where条件的时候直接传具体的值。
   *
   * @param model 查询条件对象，包含查询条件和分页参数（page、size字段）
   * @return WhereBuilderNow实例，支持链式调用
   * @throws BusinessException 如果model为null
   * @example
   *     <pre>{@code
   * UserQuery query = new UserQuery();
   * query.setUsername("admin");
   * query.setPage(1);
   * query.setSize(20);
   *
   * WhereBuilderNow<UserEntity> builder = new WhereBuilderNow<>();
   * builder.init(query); // 初始化后，可以从query对象中提取值
   * }</pre>
   */
  public WhereBuilderNow<T> init(Object model) {
    if (model == null) {
      throw new BusinessException("参数对象不能为空");
    }
    this.model = model;
    return this;
  }

  /**
   * 从model对象中提取分页参数，生成Pageable对象
   *
   * <p>会从model对象中查找page和size字段（支持Page、page、Size、size） 前端传递的page是从1开始计数，会自动转换为从0开始
   *
   * @return Pageable对象
   * @example
   *     <pre>{@code
   * UserQuery query = new UserQuery();
   * query.setPage(1);  // 前端传1表示第1页
   * query.setSize(20);
   *
   * WhereBuilderNow<UserEntity> builder = new WhereBuilderNow<>();
   * builder.init(query);
   * Pageable pageable = builder.getPageable(); // 会自动转换为PageRequest.of(0, 20)
   * }</pre>
   */
  public Pageable getPageable() {
    Object page = getValueByFieldName("Page");
    page = page != null ? page : getValueByFieldName("page");
    int iPage = page instanceof Integer ? Math.max((Integer) page - 1, 0) : defaultPage;

    Object size = getValueByFieldName("Size");
    size = size != null ? size : getValueByFieldName("size");
    int iSize = size instanceof Integer ? Math.max((Integer) size, 1) : defaultSize;
    return PageRequest.of(iPage, iSize);
  }

  /**
   * 手动指定分页参数，生成Pageable对象
   *
   * @param page 页码（从1开始，会自动转换为从0开始）
   * @param size 每页大小
   * @return Pageable对象
   */
  public Pageable getPageable(int page, int size) {
    return getPageable(null, page, size);
  }

  /**
   * 从model对象中提取分页参数，并指定排序，生成Pageable对象
   *
   * @param sort 排序对象
   * @return Pageable对象
   */
  public Pageable getPageable(Sort sort) {
    Object page = getValueByFieldName("Page");
    page = page != null ? page : getValueByFieldName("page");
    int iPage = page instanceof Integer ? Math.max((Integer) page - 1, 0) : defaultPage;

    Object size = getValueByFieldName("Size");
    size = size != null ? size : getValueByFieldName("size");
    int iSize = size instanceof Integer ? Math.max((Integer) size, 1) : defaultSize;

    return sort != null ? PageRequest.of(iPage, iSize, sort) : PageRequest.of(iPage, iSize);
  }

  /**
   * 使用PageQuery对象生成Pageable对象
   *
   * @param pageQuery PageQuery对象，包含page和size字段
   * @return Pageable对象
   */
  public Pageable getPageable(PageQuery pageQuery) {
    return getPageable(pageQuery.getPage(), pageQuery.getSize());
  }

  /**
   * 手动指定分页参数和排序，生成Pageable对象
   *
   * @param sort 排序对象
   * @param page 页码（从1开始，会自动转换为从0开始）
   * @param size 每页大小
   * @return Pageable对象
   */
  public Pageable getPageable(Sort sort, int page, int size) {
    int iPage = Math.max(page - 1, 0);
    int iSize = Math.max(size, 1);

    return sort != null ? PageRequest.of(iPage, iSize, sort) : PageRequest.of(iPage, iSize);
  }

  /**
   * 构建Specification对象（使用Consumer方式）
   *
   * <p>这是推荐的使用方式，可以通过lambda表达式构建查询条件，代码更简洁。
   *
   * @param builder Consumer函数，用于构建查询条件
   * @return Specification对象，可直接用于JpaRepository的findAll方法
   * @example
   *     <pre>{@code
   * Specification<UserEntity> spec = builder.build(w -> {
   *     w.stringContain("username");
   *     w.intEqual("status");
   *     w.ascOrder("createTime");
   * });
   *
   * Page<UserEntity> users = userDao.findAll(spec, pageable);
   * }</pre>
   */
  public Specification<T> build(Consumer<WhereBuilderNow<T>> builder) {
    return (Specification<T>)
        (root, query, criteriaBuilder) -> {
          this.criteriaBuilder = criteriaBuilder;
          this.root = root;
          builder.accept(this);
          if (this.predicate == null) {
            this.predicate = criteriaBuilder.equal(criteriaBuilder.literal(1), 1);
          }
          return query.where(this.predicate).orderBy(criteriaOrders).getRestriction();
        };
  }

  /**
   * 构建Specification对象（不使用Consumer）
   *
   * <p>如果已经通过其他方式设置了条件，可以直接调用此方法构建Specification。
   *
   * @return Specification对象
   */
  public Specification<T> build() {
    return (Specification<T>)
        (root, query, criteriaBuilder) -> {
          this.criteriaBuilder = criteriaBuilder;
          this.root = root;
          if (this.predicate == null) {
            this.predicate = criteriaBuilder.equal(criteriaBuilder.literal(1), 1);
          }
          return query.where(this.predicate).orderBy(criteriaOrders).getRestriction();
        };
  }

  // ==================== 排序方法 ====================

  /**
   * 添加升序排序
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> ascOrder(String column) {
    if (!validate(column)) {
      return this;
    }
    criteriaOrders.add(criteriaBuilder.asc(root.get(column)));
    return this;
  }

  /**
   * 添加降序排序
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> descOrder(String column) {
    if (!validate(column)) {
      return this;
    }
    criteriaOrders.add(criteriaBuilder.desc(root.get(column)));
    return this;
  }

  // ==================== 布尔类型条件 ====================

  /**
   * 布尔值等于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> booleanEqual(String column, Boolean value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.equal(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.equal(rootKey, value)));
  }

  /**
   * 布尔值等于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> booleanEqual(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof Boolean) {
      return booleanEqual(column, (Boolean) value);
    }
    return this;
  }

  /**
   * 布尔值不等于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> booleanNotEqual(String column, Boolean value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.notEqual(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.notEqual(rootKey, value)));
  }

  /**
   * 布尔值不等于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> booleanNotEqual(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof Boolean) {
      return booleanNotEqual(column, (Boolean) value);
    }
    return this;
  }

  /**
   * 布尔值为true条件
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> booleanIsTrue(String column) {
    return booleanEqual(column, true);
  }

  /**
   * 布尔值为false条件
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> booleanIsFalse(String column) {
    return booleanEqual(column, false);
  }

  // ==================== 字符串类型条件 ====================

  /**
   * 字符串等于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringEqual(String column, String value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.equal(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.equal(rootKey, value)));
  }

  /**
   * 字符串等于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringEqual(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof String && StringUtils.hasLength((String) value)) {
      return stringEqual(column, (String) value);
    }
    return this;
  }

  /**
   * 枚举等于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> enumEqual(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof Enum<?> anEnum) {
      return enumEqual(column, anEnum);
    }
    return this;
  }

  /**
   * 枚举等于条件
   *
   * @param column 字段名
   * @param value 枚举值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> enumEqual(String column, Enum<?> value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.equal(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.equal(rootKey, value)));
  }

  /**
   * 字符串不等于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringNotEqual(String column, String value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.notEqual(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.notEqual(rootKey, value)));
  }

  /**
   * 字符串不等于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringNotEqual(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof String && StringUtils.hasLength((String) value)) {
      return stringNotEqual(column, (String) value);
    }
    return this;
  }

  /**
   * 字符串不在列表中
   *
   * @param column 字段名
   * @param values 值列表
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringNotIn(String column, List<String> values) {
    return condition(
        column,
        values,
        (rootKey) -> criteriaBuilder.not(rootKey.in(values)),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.not(rootKey.in(values))));
  }

  /**
   * 字符串不在列表中（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringNotIn(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof List) {
      return stringNotIn(column, (List<String>) value);
    }
    return this;
  }

  /**
   * 字符串在列表中
   *
   * @param column 字段名
   * @param values 值列表
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringIn(String column, List<String> values) {
    return condition(
        column,
        values,
        (rootKey) -> rootKey.in(values),
        (rootKey) -> criteriaBuilder.and(predicate, rootKey.in(values)));
  }

  /**
   * 字符串在列表中（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringIn(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof List) {
      return stringIn(column, (List<String>) value);
    }
    return this;
  }

  /**
   * 字符串包含条件（模糊查询，前后都有%）
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringContain(String column, String value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.like(rootKey, "%" + value + "%"),
        (rootKey) ->
            criteriaBuilder.and(predicate, criteriaBuilder.like(rootKey, "%" + value + "%")));
  }

  /**
   * 字符串右匹配条件（以...开头）
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringContainRight(String column, String value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.like(rootKey, value + "%"),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.like(rootKey, value + "%")));
  }

  /**
   * 字符串左匹配条件（以...结尾）
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringContainLift(String column, String value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.like(rootKey, "%" + value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.like(rootKey, "%" + value)));
  }

  /**
   * 字符串包含条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringContain(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof String && StringUtils.hasLength((String) value)) {
      return stringContain(column, (String) value);
    }
    return this;
  }

  /**
   * 字符串不包含条件（不包含指定字符串）
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringNotContain(String column, String value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.not(criteriaBuilder.like(rootKey, "%" + value + "%")),
        (rootKey) ->
            criteriaBuilder.and(
                predicate, criteriaBuilder.not(criteriaBuilder.like(rootKey, "%" + value + "%"))));
  }

  /**
   * 字符串不包含条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringNotContain(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof String && StringUtils.hasLength((String) value)) {
      return stringNotContain(column, (String) value);
    }
    return this;
  }

  /**
   * 字符串以...开头（别名方法，与stringContainRight相同）
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringStartWith(String column, String value) {
    return stringContainRight(column, value);
  }

  /**
   * 字符串以...开头（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringStartWith(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof String && StringUtils.hasLength((String) value)) {
      return stringStartWith(column, (String) value);
    }
    return this;
  }

  /**
   * 字符串以...结尾（别名方法，与stringContainLift相同）
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringEndWith(String column, String value) {
    return stringContainLift(column, value);
  }

  /**
   * 字符串以...结尾（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringEndWith(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof String && StringUtils.hasLength((String) value)) {
      return stringEndWith(column, (String) value);
    }
    return this;
  }

  /**
   * 字符串为空（去除空格后等于空字符串）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringIsBlank(String column) {
    if (!validate(column)) {
      return this;
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.equal(criteriaBuilder.trim(rootKey), "")
            : criteriaBuilder.and(
                predicate, criteriaBuilder.equal(criteriaBuilder.trim(rootKey), ""));
    return this;
  }

  /**
   * 字符串不为空（去除空格后不等于空字符串）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringIsNotBlank(String column) {
    if (!validate(column)) {
      return this;
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.notEqual(criteriaBuilder.trim(rootKey), "")
            : criteriaBuilder.and(
                predicate, criteriaBuilder.notEqual(criteriaBuilder.trim(rootKey), ""));
    return this;
  }

  /**
   * 字符串不为空或不为null
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringIsNotBlankOrNotNull(String column) {
    if (!validate(column)) {
      return this;
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.or(
                criteriaBuilder.notEqual(criteriaBuilder.trim(rootKey), ""),
                criteriaBuilder.isNotNull(rootKey))
            : criteriaBuilder.and(
                predicate,
                criteriaBuilder.or(
                    criteriaBuilder.notEqual(criteriaBuilder.trim(rootKey), ""),
                    criteriaBuilder.isNotNull(rootKey)));
    return this;
  }

  /**
   * 字符串为空或null
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> stringIsBlankOrNull(String column) {
    if (!validate(column)) {
      return this;
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.or(
                criteriaBuilder.equal(criteriaBuilder.trim(rootKey), ""),
                criteriaBuilder.isNull(rootKey))
            : criteriaBuilder.and(
                predicate,
                criteriaBuilder.or(
                    criteriaBuilder.equal(criteriaBuilder.trim(rootKey), ""),
                    criteriaBuilder.isNull(rootKey)));
    return this;
  }

  /**
   * 模糊查询（不区分大小写）
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> like(String column, String value) {
    if (model != null && value != null && !value.isEmpty()) {
      Path<String> path = root.get(column);
      Predicate likePredicate =
          criteriaBuilder.like(criteriaBuilder.lower(path), "%" + value.toLowerCase() + "%");
      predicate = criteriaBuilder.and(predicate, likePredicate);
    }
    return this;
  }

  // ==================== 整数类型条件 ====================

  /**
   * 整数等于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> intEqual(String column, Integer value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.equal(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.equal(rootKey, value)));
  }

  /**
   * 整数等于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> intEqual(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof Integer) {
      return intEqual(column, (Integer) value);
    }
    return this;
  }

  /**
   * 整数不等于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> intNotEqual(String column, Integer value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.notEqual(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.notEqual(rootKey, value)));
  }

  /**
   * 整数不等于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> intNotEqual(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof Integer) {
      return intNotEqual(column, (Integer) value);
    }
    return this;
  }

  /**
   * 整数大于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> intThan(String column, Integer value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.gt(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.gt(rootKey, value)));
  }

  /**
   * 整数大于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> intThan(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof Integer) {
      return intThan(column, (Integer) value);
    }
    return this;
  }

  /**
   * 整数小于等于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> intLess(String column, Integer value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.le(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.le(rootKey, value)));
  }

  /**
   * 整数小于等于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> intLess(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof Integer) {
      return intLess(column, (Integer) value);
    }
    return this;
  }

  /**
   * 整数大于等于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> intGreaterThanOrEqual(String column, Integer value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.ge(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.ge(rootKey, value)));
  }

  /**
   * 整数大于等于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> intGreaterThanOrEqual(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof Integer) {
      return intGreaterThanOrEqual(column, (Integer) value);
    }
    return this;
  }

  /**
   * 整数小于条件（不包含等于）
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> intLessThan(String column, Integer value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.lt(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.lt(rootKey, value)));
  }

  /**
   * 整数小于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> intLessThan(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof Integer) {
      return intLessThan(column, (Integer) value);
    }
    return this;
  }

  /**
   * 整数在列表中
   *
   * @param column 字段名
   * @param values 值列表
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> intIn(String column, List<Integer> values) {
    if (values != null && !values.isEmpty()) {
      return condition(
          column,
          values,
          (rootKey) -> rootKey.in(values),
          (rootKey) -> criteriaBuilder.and(predicate, rootKey.in(values)));
    } else {
      return this;
    }
  }

  /**
   * 整数不在列表中
   *
   * @param column 字段名
   * @param values 值列表
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> intNotIn(String column, List<Integer> values) {
    if (values != null && !values.isEmpty()) {
      return condition(
          column,
          values,
          (rootKey) -> criteriaBuilder.not(rootKey.in(values)),
          (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.not(rootKey.in(values))));
    } else {
      return this;
    }
  }

  /**
   * 整数不在列表中（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> intNotIn(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof List) {
      return intNotIn(column, (List<Integer>) value);
    }
    return this;
  }

  /**
   * 整数区间条件
   *
   * @param column 字段名
   * @param value 值列表，包含两个元素：[起始值, 结束值]
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> intBetween(String column, List<Integer> value) {
    if (!validate(column)) {
      return this;
    }
    if (value == null) {
      return this;
    }
    int start = value.get(0) == null ? Integer.MIN_VALUE : value.get(0);
    int end = value.get(1) == null ? Integer.MAX_VALUE : value.get(1);
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.between(rootKey, start, end)
            : criteriaBuilder.and(predicate, criteriaBuilder.between(rootKey, start, end));
    return this;
  }

  // ==================== 长整型类型条件 ====================

  /**
   * 长整型等于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> longEqual(String column, Long value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.equal(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.equal(rootKey, value)));
  }

  /**
   * 长整型等于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> longEqual(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof Long) {
      return longEqual(column, (Long) value);
    }
    return this;
  }

  /**
   * 长整型大于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> longThan(String column, Long value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.gt(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.gt(rootKey, value)));
  }

  /**
   * 长整型大于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> longThan(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof Long) {
      return longThan(column, (Long) value);
    }
    return this;
  }

  /**
   * 长整型小于等于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> longLess(String column, Long value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.le(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.le(rootKey, value)));
  }

  /**
   * 长整型小于等于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> longLess(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof Long) {
      return longLess(column, (Long) value);
    }
    return this;
  }

  /**
   * 长整型不等于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> longNotEqual(String column, Long value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.notEqual(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.notEqual(rootKey, value)));
  }

  /**
   * 长整型不等于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> longNotEqual(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof Long) {
      return longNotEqual(column, (Long) value);
    }
    return this;
  }

  /**
   * 长整型大于等于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> longGreaterThanOrEqual(String column, Long value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.ge(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.ge(rootKey, value)));
  }

  /**
   * 长整型大于等于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> longGreaterThanOrEqual(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof Long) {
      return longGreaterThanOrEqual(column, (Long) value);
    }
    return this;
  }

  /**
   * 长整型小于条件（不包含等于）
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> longLessThan(String column, Long value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.lt(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.lt(rootKey, value)));
  }

  /**
   * 长整型小于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> longLessThan(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof Long) {
      return longLessThan(column, (Long) value);
    }
    return this;
  }

  /**
   * 长整型在列表中
   *
   * @param column 字段名
   * @param values 值列表
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> longIn(String column, List<Long> values) {
    if (values != null && !values.isEmpty()) {
      return condition(
          column,
          values,
          (rootKey) -> rootKey.in(values),
          (rootKey) -> criteriaBuilder.and(predicate, rootKey.in(values)));
    } else {
      return this;
    }
  }

  /**
   * 长整型在列表中（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> longIn(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof List) {
      return longIn(column, (List<Long>) value);
    }
    return this;
  }

  /**
   * 长整型不在列表中
   *
   * @param column 字段名
   * @param values 值列表
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> longNotIn(String column, List<Long> values) {
    if (values != null && !values.isEmpty()) {
      return condition(
          column,
          values,
          (rootKey) -> criteriaBuilder.not(rootKey.in(values)),
          (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.not(rootKey.in(values))));
    } else {
      return this;
    }
  }

  /**
   * 长整型不在列表中（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> longNotIn(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof List) {
      return longNotIn(column, (List<Long>) value);
    }
    return this;
  }

  /**
   * 长整型区间条件
   *
   * @param column 字段名
   * @param startValue 起始值
   * @param endValue 结束值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> longBetween(String column, Long startValue, Long endValue) {
    if (!validate(column)) {
      return this;
    }
    if (startValue == null || endValue == null) {
      return this;
    }
    Long start = startValue == null ? Long.MIN_VALUE : startValue;
    Long end = endValue == null ? Long.MAX_VALUE : endValue;
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.between(rootKey, start, end)
            : criteriaBuilder.and(predicate, criteriaBuilder.between(rootKey, start, end));
    return this;
  }

  // ==================== 日期时间类型条件 ====================

  /**
   * 日期时间大于条件
   *
   * @param column 字段名
   * @param value 日期时间字符串
   * @param format 日期格式，默认为"yyyy-MM-dd HH:mm:ss"
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateTimeThan(String column, String value, String format) {
    if (!validate(column, value)) {
      return this;
    }
    if (!StringUtils.hasLength(format)) {
      format = "yyyy-MM-dd HH:mm:ss";
    }
    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(format);
    LocalDateTime time;
    try {
      time = LocalDateTime.parse(value, dateTimeFormatter);
    } catch (DateTimeParseException e) {
      time = LocalDateTime.ofInstant(Instant.ofEpochMilli(0), ZoneId.systemDefault());
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.greaterThan(rootKey, time)
            : criteriaBuilder.and(predicate, criteriaBuilder.greaterThan(rootKey, time));
    return this;
  }

  /**
   * 日期时间大于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @param format 日期格式
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateTimeThan(String column, String format) {
    Object value = getValueByFieldName(column);
    if (value instanceof String) {
      return dateTimeThan(column, (String) value, format);
    }
    return this;
  }

  /**
   * 日期时间大于条件（使用默认格式）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateTimeThan(String column) {
    return dateTimeThan(column, null);
  }

  /**
   * 日期时间大于等于条件
   *
   * @param column 字段名
   * @param value 日期时间字符串
   * @param format 日期格式，默认为"yyyy-MM-dd HH:mm:ss"
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateTimeThanEqual(String column, String value, String format) {
    if (!validate(column, value)) {
      return this;
    }
    if (!StringUtils.hasLength(format)) {
      format = "yyyy-MM-dd HH:mm:ss";
    }
    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(format);
    LocalDateTime time;
    try {
      time = LocalDateTime.parse(value, dateTimeFormatter);
    } catch (DateTimeParseException e) {
      time = LocalDateTime.ofInstant(Instant.ofEpochMilli(0), ZoneId.systemDefault());
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.greaterThanOrEqualTo(rootKey, time)
            : criteriaBuilder.and(predicate, criteriaBuilder.greaterThanOrEqualTo(rootKey, time));
    return this;
  }

  /**
   * 日期时间小于条件
   *
   * @param column 字段名
   * @param value 日期时间字符串
   * @param format 日期格式，默认为"yyyy-MM-dd HH:mm:ss"
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateTimeLess(String column, String value, String format) {
    if (!validate(column, value)) {
      return this;
    }
    if (!StringUtils.hasLength(format)) {
      format = "yyyy-MM-dd HH:mm:ss";
    }
    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(format);
    LocalDateTime time;
    try {
      time = LocalDateTime.parse(value, dateTimeFormatter);
    } catch (DateTimeParseException e) {
      time = LocalDateTime.ofInstant(Instant.ofEpochMilli(4072579427000L), ZoneId.systemDefault());
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.lessThan(rootKey, time)
            : criteriaBuilder.and(predicate, criteriaBuilder.lessThan(rootKey, time));
    return this;
  }

  /**
   * 日期时间小于等于条件
   *
   * @param column 字段名
   * @param value 日期时间字符串
   * @param format 日期格式，默认为"yyyy-MM-dd HH:mm:ss"
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateTimeLessEqual(String column, String value, String format) {
    if (!validate(column, value)) {
      return this;
    }
    if (!StringUtils.hasLength(format)) {
      format = "yyyy-MM-dd HH:mm:ss";
    }
    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(format);
    LocalDateTime time;
    try {
      time = LocalDateTime.parse(value, dateTimeFormatter);
    } catch (DateTimeParseException e) {
      time = LocalDateTime.ofInstant(Instant.ofEpochMilli(4072579427000L), ZoneId.systemDefault());
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.lessThanOrEqualTo(rootKey, time)
            : criteriaBuilder.and(predicate, criteriaBuilder.lessThanOrEqualTo(rootKey, time));
    return this;
  }

  /**
   * 日期时间小于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @param format 日期格式
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateTimeLess(String column, String format) {
    Object value = getValueByFieldName(column);
    if (value instanceof String) {
      return dateTimeLess(column, (String) value, format);
    }
    return this;
  }

  /**
   * 日期时间小于条件（使用默认格式）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateTimeLess(String column) {
    return dateTimeLess(column, null);
  }

  /**
   * 日期时间区间条件（从List中提取）
   *
   * @param column 字段名
   * @param time 时间列表，包含两个元素：[起始时间, 结束时间]
   * @param format 日期格式
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateTimeBetween(String column, List<String> time, String format) {
    if (time == null || time.isEmpty() || time.size() < 2) {
      return this;
    }
    return dateTimeBetween(column, time.get(0), time.get(1), format);
  }

  /**
   * 日期时间等于条件
   *
   * @param column 字段名
   * @param value 日期时间字符串
   * @param format 日期格式，默认为"yyyy-MM-dd HH:mm:ss"
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateTimeEqual(String column, String value, String format) {
    if (!validate(column, value)) {
      return this;
    }
    if (!StringUtils.hasLength(format)) {
      format = "yyyy-MM-dd HH:mm:ss";
    }
    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(format);
    LocalDateTime time;
    try {
      time = LocalDateTime.parse(value, dateTimeFormatter);
    } catch (DateTimeParseException e) {
      time = LocalDateTime.ofInstant(Instant.ofEpochMilli(0), ZoneId.systemDefault());
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.equal(rootKey, time)
            : criteriaBuilder.and(predicate, criteriaBuilder.equal(rootKey, time));
    return this;
  }

  /**
   * 日期时间不等于条件
   *
   * @param column 字段名
   * @param value 日期时间字符串
   * @param format 日期格式，默认为"yyyy-MM-dd HH:mm:ss"
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateTimeNotEqual(String column, String value, String format) {
    if (!validate(column, value)) {
      return this;
    }
    if (!StringUtils.hasLength(format)) {
      format = "yyyy-MM-dd HH:mm:ss";
    }
    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(format);
    LocalDateTime time;
    try {
      time = LocalDateTime.parse(value, dateTimeFormatter);
    } catch (DateTimeParseException e) {
      time = LocalDateTime.ofInstant(Instant.ofEpochMilli(0), ZoneId.systemDefault());
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.notEqual(rootKey, time)
            : criteriaBuilder.and(predicate, criteriaBuilder.notEqual(rootKey, time));
    return this;
  }

  /**
   * 日期时间区间条件
   *
   * @param column 字段名
   * @param startTime 起始时间字符串
   * @param endTime 结束时间字符串
   * @param format 日期格式，默认为"yyyy-MM-dd HH:mm:ss"
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateTimeBetween(
      String column, String startTime, String endTime, String format) {
    // 开始时间和结束时间可以单个为空，不能全部为空
    if (!StringUtils.hasLength(startTime) && !StringUtils.hasLength(endTime)) {
      return this;
    }
    if (!StringUtils.hasLength(startTime) && StringUtils.hasLength(endTime)) {
      return dateTimeLess(column, endTime, format);
    }
    if (StringUtils.hasLength(startTime) && !StringUtils.hasLength(endTime)) {
      return dateTimeThan(column, startTime, format);
    }
    if (!validate(column)) {
      return this;
    }
    if (!StringUtils.hasLength(format)) {
      format = "yyyy-MM-dd HH:mm:ss";
    }
    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(format);
    LocalDateTime localStartDateTime;
    try {
      localStartDateTime = LocalDateTime.parse(startTime, dateTimeFormatter);
    } catch (DateTimeParseException e) {
      localStartDateTime = LocalDateTime.ofInstant(Instant.ofEpochMilli(0), ZoneId.systemDefault());
    }
    LocalDateTime localEndDateTime;
    try {
      localEndDateTime = LocalDateTime.parse(endTime, dateTimeFormatter);
    } catch (DateTimeParseException e) {
      localEndDateTime =
          LocalDateTime.ofInstant(Instant.ofEpochMilli(4072579427000L), ZoneId.systemDefault());
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.between(rootKey, localStartDateTime, localEndDateTime)
            : criteriaBuilder.and(
                predicate, criteriaBuilder.between(rootKey, localStartDateTime, localEndDateTime));
    return this;
  }

  // ==================== 日期类型条件 ====================

  /**
   * 日期区间条件（从List中提取）
   *
   * @param column 字段名
   * @param time 日期列表，包含两个元素：[起始日期, 结束日期]
   * @param format 日期格式
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateBetween(String column, List<String> time, String format) {
    if (time == null || time.isEmpty() || time.size() < 2) {
      return this;
    }
    return dateBetween(column, time.get(0), time.get(1), format);
  }

  /**
   * 日期区间条件
   *
   * @param column 字段名
   * @param startDate 起始日期字符串
   * @param endDate 结束日期字符串
   * @param format 日期格式，默认为"yyyy-MM-dd"
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateBetween(
      String column, String startDate, String endDate, String format) {
    // 开始时间和结束时间可以单个为空，不能全部为空
    if (!StringUtils.hasLength(startDate) && !StringUtils.hasLength(endDate)) {
      return this;
    }
    if (!StringUtils.hasLength(startDate) && StringUtils.hasLength(endDate)) {
      return dateLess(column, endDate, format);
    }
    if (StringUtils.hasLength(startDate) && !StringUtils.hasLength(endDate)) {
      return dateThan(column, startDate, format);
    }
    if (!validate(column)) {
      return this;
    }
    if (!StringUtils.hasLength(format)) {
      format = "yyyy-MM-dd";
    }
    DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern(format);
    LocalDate localStartDate;
    try {
      localStartDate = LocalDate.parse(startDate, dateFormatter);
    } catch (DateTimeParseException e) {
      localStartDate = LocalDate.ofEpochDay(0);
    }
    LocalDate localEndDate;
    try {
      localEndDate = LocalDate.parse(endDate, dateFormatter);
    } catch (DateTimeParseException e) {
      localEndDate = LocalDate.ofEpochDay(40726);
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.between(rootKey, localStartDate, localEndDate)
            : criteriaBuilder.and(
                predicate, criteriaBuilder.between(rootKey, localStartDate, localEndDate));
    return this;
  }

  /**
   * 日期小于条件
   *
   * @param column 字段名
   * @param value 日期字符串
   * @param format 日期格式，默认为"yyyy-MM-dd"
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateLess(String column, String value, String format) {
    if (!validate(column, value)) {
      return this;
    }
    if (!StringUtils.hasLength(format)) {
      format = "yyyy-MM-dd";
    }
    DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern(format);
    LocalDate date;
    try {
      date = LocalDate.parse(value, dateFormatter);
    } catch (DateTimeParseException e) {
      date = LocalDate.ofEpochDay(40726);
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.lessThan(rootKey, date)
            : criteriaBuilder.and(predicate, criteriaBuilder.lessThan(rootKey, date));
    return this;
  }

  /**
   * 日期大于条件
   *
   * @param column 字段名
   * @param value 日期字符串
   * @param format 日期格式，默认为"yyyy-MM-dd"
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateThan(String column, String value, String format) {
    if (!validate(column, value)) {
      return this;
    }
    if (!StringUtils.hasLength(format)) {
      format = "yyyy-MM-dd";
    }
    DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern(format);
    LocalDate date;
    try {
      date = LocalDate.parse(value, dateFormatter);
    } catch (DateTimeParseException e) {
      date = LocalDate.ofEpochDay(0);
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.greaterThan(rootKey, date)
            : criteriaBuilder.and(predicate, criteriaBuilder.greaterThan(rootKey, date));
    return this;
  }

  /**
   * 日期等于条件
   *
   * @param column 字段名
   * @param value 日期字符串
   * @param format 日期格式，默认为"yyyy-MM-dd"
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateEqual(String column, String value, String format) {
    if (!validate(column, value)) {
      return this;
    }
    if (!StringUtils.hasLength(format)) {
      format = "yyyy-MM-dd";
    }
    DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern(format);
    LocalDate date;
    try {
      date = LocalDate.parse(value, dateFormatter);
    } catch (DateTimeParseException e) {
      date = LocalDate.ofEpochDay(0);
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.equal(rootKey, date)
            : criteriaBuilder.and(predicate, criteriaBuilder.equal(rootKey, date));
    return this;
  }

  /**
   * 日期不等于条件
   *
   * @param column 字段名
   * @param value 日期字符串
   * @param format 日期格式，默认为"yyyy-MM-dd"
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateNotEqual(String column, String value, String format) {
    if (!validate(column, value)) {
      return this;
    }
    if (!StringUtils.hasLength(format)) {
      format = "yyyy-MM-dd";
    }
    DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern(format);
    LocalDate date;
    try {
      date = LocalDate.parse(value, dateFormatter);
    } catch (DateTimeParseException e) {
      date = LocalDate.ofEpochDay(0);
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.notEqual(rootKey, date)
            : criteriaBuilder.and(predicate, criteriaBuilder.notEqual(rootKey, date));
    return this;
  }

  /**
   * 日期大于等于条件
   *
   * @param column 字段名
   * @param value 日期字符串
   * @param format 日期格式，默认为"yyyy-MM-dd"
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateGreaterThanOrEqual(String column, String value, String format) {
    if (!validate(column, value)) {
      return this;
    }
    if (!StringUtils.hasLength(format)) {
      format = "yyyy-MM-dd";
    }
    DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern(format);
    LocalDate date;
    try {
      date = LocalDate.parse(value, dateFormatter);
    } catch (DateTimeParseException e) {
      date = LocalDate.ofEpochDay(0);
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.greaterThanOrEqualTo(rootKey, date)
            : criteriaBuilder.and(predicate, criteriaBuilder.greaterThanOrEqualTo(rootKey, date));
    return this;
  }

  /**
   * 日期小于等于条件
   *
   * @param column 字段名
   * @param value 日期字符串
   * @param format 日期格式，默认为"yyyy-MM-dd"
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> dateLessThanOrEqual(String column, String value, String format) {
    if (!validate(column, value)) {
      return this;
    }
    if (!StringUtils.hasLength(format)) {
      format = "yyyy-MM-dd";
    }
    DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern(format);
    LocalDate date;
    try {
      date = LocalDate.parse(value, dateFormatter);
    } catch (DateTimeParseException e) {
      date = LocalDate.ofEpochDay(40726);
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.lessThanOrEqualTo(rootKey, date)
            : criteriaBuilder.and(predicate, criteriaBuilder.lessThanOrEqualTo(rootKey, date));
    return this;
  }

  // ==================== 时间类型条件 ====================

  /**
   * 时间区间条件
   *
   * @param column 字段名
   * @param startTime 起始时间字符串
   * @param endTime 结束时间字符串
   * @param format 时间格式，默认为"HH:mm:ss"
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> timeBetween(
      String column, String startTime, String endTime, String format) {
    // 开始时间和结束时间可以单个为空，但不能全部为空
    if (!StringUtils.hasLength(startTime) && !StringUtils.hasLength(endTime)) {
      return this;
    }
    if (!StringUtils.hasLength(startTime) && StringUtils.hasLength(endTime)) {
      return timeLess(column, endTime, format);
    }
    if (StringUtils.hasLength(startTime) && !StringUtils.hasLength(endTime)) {
      return timeThan(column, startTime, format);
    }
    if (!validate(column)) {
      return this;
    }
    if (!StringUtils.hasLength(format)) {
      format = "HH:mm:ss";
    }
    DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern(format);
    LocalTime localStartTime;
    try {
      localStartTime = LocalTime.parse(startTime, timeFormatter);
    } catch (DateTimeParseException e) {
      localStartTime = LocalTime.MIN;
    }
    LocalTime localEndTime;
    try {
      localEndTime = LocalTime.parse(endTime, timeFormatter);
    } catch (DateTimeParseException e) {
      localEndTime = LocalTime.MAX;
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.between(rootKey, localStartTime, localEndTime)
            : criteriaBuilder.and(
                predicate, criteriaBuilder.between(rootKey, localStartTime, localEndTime));
    return this;
  }

  /**
   * 时间小于条件
   *
   * @param column 字段名
   * @param value 时间字符串
   * @param format 时间格式，默认为"HH:mm:ss"
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> timeLess(String column, String value, String format) {
    if (!validate(column, value)) {
      return this;
    }
    if (!StringUtils.hasLength(format)) {
      format = "HH:mm:ss";
    }
    DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern(format);
    LocalTime time;
    try {
      time = LocalTime.parse(value, timeFormatter);
    } catch (DateTimeParseException e) {
      time = LocalTime.MAX;
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.lessThan(rootKey, time)
            : criteriaBuilder.and(predicate, criteriaBuilder.lessThan(rootKey, time));
    return this;
  }

  /**
   * 时间大于条件
   *
   * @param column 字段名
   * @param value 时间字符串
   * @param format 时间格式，默认为"HH:mm:ss"
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> timeThan(String column, String value, String format) {
    if (!validate(column, value)) {
      return this;
    }
    if (!StringUtils.hasLength(format)) {
      format = "HH:mm:ss";
    }
    DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern(format);
    LocalTime time;
    try {
      time = LocalTime.parse(value, timeFormatter);
    } catch (DateTimeParseException e) {
      time = LocalTime.MIN;
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.greaterThan(rootKey, time)
            : criteriaBuilder.and(predicate, criteriaBuilder.greaterThan(rootKey, time));
    return this;
  }

  // ==================== 其他条件 ====================

  /**
   * 字段为null条件
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> isNull(String column) {
    if (!validate(column)) {
      return this;
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.isNull(rootKey)
            : criteriaBuilder.and(predicate, criteriaBuilder.isNull(rootKey));
    return this;
  }

  /**
   * 字段不为null条件
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> isNotNull(String column) {
    if (!validate(column)) {
      return this;
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.isNotNull(rootKey)
            : criteriaBuilder.and(predicate, criteriaBuilder.isNotNull(rootKey));
    return this;
  }

  /**
   * 关键词搜索（在多个字段中搜索，使用OR连接）
   *
   * <p>在多个字段中搜索关键词，只要有一个字段匹配就返回
   *
   * @param keyword 关键词
   * @param fields 要搜索的字段列表
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> keywordSearch(String keyword, String... fields) {
    if (model != null
        && keyword != null
        && !keyword.isEmpty()
        && fields != null
        && fields.length > 0) {
      List<Predicate> keywordPredicate = new ArrayList<>();
      for (String field : fields) {
        Path<String> path = root.get(field);
        Predicate or =
            criteriaBuilder.like(criteriaBuilder.lower(path), "%" + keyword.toLowerCase() + "%");
        keywordPredicate.add(or);
      }
      predicate =
          criteriaBuilder.and(criteriaBuilder.or(keywordPredicate.toArray(Predicate[]::new)));
    }
    return this;
  }

  /**
   * 关键词精确搜索（在多个字段中搜索，使用OR连接）
   *
   * @param keyword 关键词
   * @param fields 要搜索的字段列表
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> keywordSearch2(String keyword, String... fields) {
    if (model != null
        && keyword != null
        && !keyword.isEmpty()
        && fields != null
        && fields.length > 0) {
      List<Predicate> keywordPredicate = new ArrayList<>();
      for (String field : fields) {
        Path<String> path = root.get(field);
        Predicate or = criteriaBuilder.equal(criteriaBuilder.lower(path), keyword.toLowerCase());
        keywordPredicate.add(or);
      }
      predicate =
          criteriaBuilder.and(criteriaBuilder.or(keywordPredicate.toArray(Predicate[]::new)));
    }
    return this;
  }

  /**
   * 字符串首字符升序排序（用于拼音排序）
   *
   * @param pinyinColumn 拼音字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> ascOrderString(String pinyinColumn) {
    if (!validate(pinyinColumn)) {
      return this;
    }

    Expression<String> expression = root.get(pinyinColumn);
    Order order = criteriaBuilder.asc(expression);
    criteriaOrders.add(order);

    return this;
  }

  /**
   * 将List转换成分页对象
   *
   * @param list 列表
   * @param pageable 分页参数
   * @return Page对象
   */
  public <R> Page<R> listToPage(List<R> list, Pageable pageable) {
    int start = (int) pageable.getOffset();
    int end = Math.min((start + pageable.getPageSize()), list.size());
    return new PageImpl<>(list.subList(start, end), pageable, list.size());
  }

  // ==================== BigDecimal类型条件 ====================

  /**
   * BigDecimal小于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> bigDecimalLessThan(String column, BigDecimal value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.lessThan(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.lessThan(rootKey, value)));
  }

  /**
   * BigDecimal小于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> bigDecimalLessThan(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof BigDecimal) {
      return bigDecimalLessThan(column, (BigDecimal) value);
    }
    return this;
  }

  /**
   * BigDecimal大于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> bigDecimalGreaterThan(String column, BigDecimal value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.greaterThan(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.greaterThan(rootKey, value)));
  }

  /**
   * BigDecimal大于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> bigDecimalGreaterThan(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof BigDecimal) {
      return bigDecimalGreaterThan(column, (BigDecimal) value);
    }
    return this;
  }

  /**
   * BigDecimal等于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> bigDecimalEqual(String column, BigDecimal value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.equal(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.equal(rootKey, value)));
  }

  /**
   * BigDecimal等于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> bigDecimalEqual(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof BigDecimal) {
      return bigDecimalEqual(column, (BigDecimal) value);
    }
    return this;
  }

  /**
   * BigDecimal不等于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> bigDecimalNotEqual(String column, BigDecimal value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.notEqual(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.notEqual(rootKey, value)));
  }

  /**
   * BigDecimal不等于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> bigDecimalNotEqual(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof BigDecimal) {
      return bigDecimalNotEqual(column, (BigDecimal) value);
    }
    return this;
  }

  /**
   * BigDecimal大于等于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> bigDecimalGreaterThanOrEqual(String column, BigDecimal value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.ge(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.ge(rootKey, value)));
  }

  /**
   * BigDecimal大于等于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> bigDecimalGreaterThanOrEqual(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof BigDecimal) {
      return bigDecimalGreaterThanOrEqual(column, (BigDecimal) value);
    }
    return this;
  }

  /**
   * BigDecimal小于等于条件
   *
   * @param column 字段名
   * @param value 值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> bigDecimalLessThanOrEqual(String column, BigDecimal value) {
    return condition(
        column,
        value,
        (rootKey) -> criteriaBuilder.le(rootKey, value),
        (rootKey) -> criteriaBuilder.and(predicate, criteriaBuilder.le(rootKey, value)));
  }

  /**
   * BigDecimal小于等于条件（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> bigDecimalLessThanOrEqual(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof BigDecimal) {
      return bigDecimalLessThanOrEqual(column, (BigDecimal) value);
    }
    return this;
  }

  /**
   * BigDecimal区间条件
   *
   * @param column 字段名
   * @param startValue 起始值
   * @param endValue 结束值
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> bigDecimalBetween(
      String column, BigDecimal startValue, BigDecimal endValue) {
    if (!validate(column)) {
      return this;
    }
    if (startValue == null || endValue == null) {
      return this;
    }
    Path rootKey = root.get(column);
    predicate =
        predicate == null
            ? criteriaBuilder.between(rootKey, startValue, endValue)
            : criteriaBuilder.and(
                predicate, criteriaBuilder.between(rootKey, startValue, endValue));
    return this;
  }

  /**
   * BigDecimal区间条件（从List中提取）
   *
   * @param column 字段名
   * @param values 值列表，包含两个元素：[起始值, 结束值]
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> bigDecimalBetween(String column, List<BigDecimal> values) {
    if (values == null || values.isEmpty() || values.size() < 2) {
      return this;
    }
    return bigDecimalBetween(column, values.get(0), values.get(1));
  }

  /**
   * BigDecimal在列表中
   *
   * @param column 字段名
   * @param values 值列表
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> bigDecimalIn(String column, List<BigDecimal> values) {
    if (values != null && !values.isEmpty()) {
      return condition(
          column,
          values,
          (rootKey) -> rootKey.in(values),
          (rootKey) -> criteriaBuilder.and(predicate, rootKey.in(values)));
    } else {
      return this;
    }
  }

  /**
   * BigDecimal在列表中（从model对象中提取值）
   *
   * @param column 字段名
   * @return WhereBuilderNow实例，支持链式调用
   */
  public WhereBuilderNow<T> bigDecimalIn(String column) {
    Object value = getValueByFieldName(column);
    if (value instanceof List) {
      return bigDecimalIn(column, (List<BigDecimal>) value);
    }
    return this;
  }

  // ==================== 私有方法 ====================

  /** 统一的条件构建方法 */
  private WhereBuilderNow<T> condition(
      String column,
      Object value,
      Function<Path, Predicate> newPredicate,
      Function<Path, Predicate> andPredicate) {
    if (!validate(column, value)) {
      return this;
    }
    Path rootKey = root.get(column);
    predicate = predicate == null ? newPredicate.apply(rootKey) : andPredicate.apply(rootKey);
    return this;
  }

  /** 统一的校验方法（带值） */
  private boolean validate(String column, Object value) {
    if (value == null) {
      return false;
    }
    return validate(column);
  }

  /** 统一的校验方法 */
  private boolean validate(String column) {
    if (this.criteriaBuilder == null || this.root == null) {
      return false;
    }
    if (!StringUtils.hasLength(column)) {
      return false;
    }
    try {
      return root.get(column) != null;
    } catch (IllegalArgumentException e) {
      return false;
    }
  }

  /** 根据字段名从model对象里获取对应的值 */
  private Object getValueByFieldName(String fieldName) {
    if (model == null) {
      return null;
    }
    try {
      // 得到属性
      Field field = getDeclaredField(fieldName);
      if (field == null) {
        return null;
      }
      // 打开私有访问
      field.setAccessible(true);
      // 获取属性值
      return field.get(model);
    } catch (Exception e) {
      return null;
    }
  }

  /**
   * 循环向上转型，获取对象的DeclaredField
   *
   * @param fieldName 字段名
   * @return 字段对象
   */
  private Field getDeclaredField(String fieldName) {
    if (model == null) {
      return null;
    }
    Field field = null;
    Class<?> clazz = model.getClass();
    for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
      try {
        return clazz.getDeclaredField(fieldName);
      } catch (Exception e) {
        // 这里甚么都不要做！并且这里的异常必须这样写，不能抛出去
        // 如果这里的异常打印或者往外抛，则就不会执行
        // clazz = clazz.getSuperclass();//最后就不会进入到父类中了
      }
    }
    return null;
  }
}
